
package com.blueocean_health.care.management.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.blueocean_health.care.management.common.LocalManager;
import com.blueocean_health.care.management.common.base.string.StringUtils;
import com.blueocean_health.care.management.domain.base.Role;
import com.blueocean_health.care.management.domain.base.SysResult;
import com.blueocean_health.care.management.domain.base.Team;
import com.blueocean_health.care.management.domain.base.TeamModule;
import com.blueocean_health.care.management.domain.base.UserAccount;
import com.blueocean_health.care.management.domain.base.UserTeam;
import com.blueocean_health.care.management.domain.dto.TeamListDto;
import com.blueocean_health.care.management.domain.vo.LoginDataVo;
import com.blueocean_health.care.management.domain.vo.OrgAndProjectTreeParam;
import com.blueocean_health.care.management.domain.vo.OrganizationVo;
import com.blueocean_health.care.management.domain.vo.Param;
import com.blueocean_health.care.management.domain.vo.TeamVo;
import com.blueocean_health.care.management.em.LocalManagerType;
import com.blueocean_health.care.management.em.ModuleStatusEnum;
import com.blueocean_health.care.management.em.ProjectManagerKeyEnum;
import com.blueocean_health.care.management.em.TeamTypeEnum;
import com.blueocean_health.care.management.exception.OrganizationException;
import com.blueocean_health.care.management.mapper.TeamMapper;
import com.blueocean_health.care.management.mapper.TeamModuleMapper;
import com.blueocean_health.care.management.mapper.UserTeamMapper;
import com.blueocean_health.care.management.service.OrgAndProjectService;
import com.blueocean_health.care.management.service.OrganizationService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

/**
* @author huyanqiu
* @date 2018年3月20日 下午2:31:50
* @version 版本号：1.0
*/
@Service
public class OrganizationServiceImpl implements OrganizationService{
	
	@Autowired
	private TeamMapper teamMapper;
	@Autowired
	private UserTeamMapper userTeamMapper;
	@Autowired
	private TeamModuleMapper teamModuleMapper;
	@Autowired
	private OrgAndProjectService orgAndProjectService;
	
	// 禁用
	private static final int disable = 2;
	// 启用
	private static final int enable = 1;
	// 删除
	private static final int delete = 3;
	
	
	/**
	 * 创建组织
	 * 1、当前登录人所属组织是否有创建权限
	 * 2、层次结构只能有5级（上级组织层级<=4即可）
	 * 3、 同一层次组织名称唯一
	 * 4、保存（组织基本信息以及组织和模块的关联关系）
	 * 5、保存组织和当前登录人所在一级组织对应的负责人角色之间的关系
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void add(OrganizationVo organizationVo) {
		// 当前登录人信息
		LoginDataVo courrentUser = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		// 上级组织
		Team parentOrg = teamMapper.findOrgById(organizationVo.getParentId());
		// 校验信息
		checkAddOrg(parentOrg, organizationVo);
		// 为了防止并发新增组织和项目，发生计算的code重复问题；5次请求后还是重复则返回异常信息。
		boolean flag = true;
		int times = 1;
		while(flag && times<=5) {
			try {
				// 保存组织信息
				save(organizationVo, parentOrg, courrentUser);
				flag = false;
			} catch(DuplicateKeyException e) {
				e.printStackTrace();
				if (times==5) {
					flag = true;
				}
			} finally {
				times++;
			}
		}
		// code不唯一
		if (times>=6) {
			throw new OrganizationException("请重新点击保存按钮");
		}
	}
	
	/**
	 * 编辑组织
	 * @throws OrganizationException 
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void modify(OrganizationVo organizationVo) {
		// 查询当前组织
		Team team = teamMapper.selectByPrimaryKey(organizationVo.getId());
		// 校验编辑组织数据是否异常
		checkEditOrg(organizationVo, team);
		// 更新组织信息
		update(organizationVo, team);
		// 更新负责人
		Map<String, String> paramsMap = new HashMap<>();
		paramsMap.put("teamId", organizationVo.getId()+"");
		paramsMap.put("manager", organizationVo.getManager());
		paramsMap.put("category", ProjectManagerKeyEnum._1.getKey());
		orgAndProjectService.updateManager(paramsMap);
	}
	
	/**
	 * 编辑组织之前--判断是否被下级占用
	 */
	@Override
	public List<Map<String, String>> modifyBefore(OrganizationVo organizationVo) {
		List<Map<String, String>> resultList = new ArrayList<>();
//		// 查询当前组织
//		Team team = teamMapper.selectByPrimaryKey(organizationVo.getId());
//		// 校验编辑组织数据是否异常
//		checkEditOrg(organizationVo, team);
//		// 批量更新组织模块信息
//		Map<String,Object> paramsMap = new HashMap<>();
//		paramsMap.put("orgId", organizationVo.getId());
//		paramsMap.put("status", team.getIsActive()+"");
//		List<TeamModule> teamModuleList = teamModuleMapper.findAllModuleByOrgId(paramsMap);
//		Set<String> removeModuleSet = new HashSet<>();
//		teamModuleList.forEach(module->{
//			removeModuleSet.add(module.getModuleId()+"");
//		});
//		Set<String> copySaveModuleSet = new HashSet<>(removeModuleSet);
//		Set<String> addModuleSet = new HashSet<>(organizationVo.getModules());
//		// 需要删除的集合
//		removeModuleSet.removeAll(addModuleSet);
//		// 需要增加的集合
//		addModuleSet.removeAll(copySaveModuleSet);
//		if (!removeModuleSet.isEmpty()) {
//			// 查询上级移除的模块，下级是否被征用
//			String subLikeCode = orgAndProjectService.getSubLikeCode(team.getCode());
//			Map<String, Object> subOrgParams = new HashMap<>();
//			subOrgParams.put("subLikeCode", subLikeCode); // 本级和下级code
//			subOrgParams.put("parentCode", team.getCode()); // 本级code 
//			subOrgParams.put("removeModuleSet", removeModuleSet); // 需要删除的集合
//			resultList = teamModuleMapper.findSubOrgModuleLikeCodeAndSet(subOrgParams);
//		}
		return resultList;
	}
	
	/**
	 * 删除组织
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void delete(Integer id) {
		Team team = teamMapper.selectByPrimaryKey(id);
		if (StringUtils.isEmpty(team)) {
//			throw new OrganizationException("指定组织不存在");
			return;
		}
		if (delete==team.getIsActive()) {
//			throw new OrganizationException("指定组织已被删除");
			return;
		}
		// 1、判断该组织是否存在下级组织/项目
		List<Team> teamList = teamMapper.isExistSub(id);
		if (!teamList.isEmpty()) {
			throw new OrganizationException("该组织存在关联数据，不允许删除");
		}
		// 2、判断是否有关联的角色
		// 2.1、该组织是否存在授权信息（通用角色中是否存在该组织的用户<过滤该组织对应的负责人>，自建角色授权）
		Role role = orgAndProjectService.getManagerPublicRole(ProjectManagerKeyEnum._1.getKey());
		Map<String, String> paramsMap = new HashMap<>();
		paramsMap.put("id", id+""); // 组织id
		paramsMap.put("roleId", role.getRoleId()+""); // 角色id
		paramsMap.put("category", ProjectManagerKeyEnum._1.getKey()); // 类别：1：负责人 2：项目经理  
		paramsMap.put("roleStatus", role.getIsActive()+""); // 角色状态
		List<UserTeam> roleAuthList = teamMapper.isExistRoleAuth(paramsMap);
		if (!roleAuthList.isEmpty()) {
			throw new OrganizationException("该组织存在关联数据，不允许删除");
		}
		// 2.2、是否存在自建角色
		List<Role> roleList = teamMapper.isExistRelationRole(id);
		if (!roleList.isEmpty()) {
			throw new OrganizationException("该组织存在关联数据，不允许删除");
		}
		// 2.3、是否存在用户
		List<UserAccount> userAccount = teamMapper.isExistUserAccount(String.valueOf(id));
		if (!userAccount.isEmpty()) {
			throw new OrganizationException("该组织存在关联数据，不允许删除");
		}
		// 3、删除
		// 更新项目状态--逻辑删除
		teamMapper.updateTeamStatusByRoId(id, delete);
		// 更新项目模块中间表状态--逻辑删除
		teamModuleMapper.updateTeamModuleStatusByRoId(id, delete);
		// 删除组织和负责人角色的关联关系--物理删除
		paramsMap.put("roleId", role.getRoleId()+"");
		paramsMap.put("teamId", id+"");
		paramsMap.put("status", role.getIsActive()+"");
		paramsMap.put("category", ProjectManagerKeyEnum._1.getKey());
		teamMapper.deleteManagerByRoleIdAndTeamId(paramsMap);
	}

	/**
	 * 启用/禁用组织 
	 * 1、禁用当前组织以及所有下级组织/项目
	 * 2、启用当前组织以及所有下级组织/项目
	 * 3、如果启用组织有直接上级或者上上级有禁用的组织，则提示（先启用上级组织），否则启用当前组织
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void status(Integer id, Integer status) {
		Team team = teamMapper.selectByPrimaryKey(id);
		if (StringUtils.isEmpty(team)) {
			return;
//			throw new OrganizationException("对应的组织不存在");
		}
		// 上级组织
		Team parentTeam = teamMapper.selectByPrimaryKey(team.getParentTeamId());
		// 启用
		if (status==enable) {
			if (parentTeam.getIsActive()==disable) {
				throw new OrganizationException("上级组织为禁用状态，现无法启用该组织");
			}
			// 所有上级的code集合
			List<String> upLikeCodeList = orgAndProjectService.getUpLikeCode(team.getCode());
			if (!upLikeCodeList.isEmpty()) {
				List<OrganizationVo> upperProjectList = teamMapper.findUpperOrgLikeParentCodeListAndStatus(upLikeCodeList, disable+"");
				if (!upperProjectList.isEmpty()) {
					throw new OrganizationException("存在上级组织为禁用状态，现无法启用该组织");
				}
			}
		}
		String subLikeCode = orgAndProjectService.getSubLikeCode(team.getCode());
		// 更新组织状态
		teamMapper.updateOrgStatusByCodeLike(subLikeCode, status);
		// 更新组织与模块中间表状态
		teamModuleMapper.updateTeamMoudleStatusByCodeLike(subLikeCode, status);
	}

	/**
	 * 获取组织详情
	 * @param id
	 * @return
	 */
	@Override 
	public TeamVo query(Integer id) {
		Team team = teamMapper.selectByPrimaryKey(id);
		if (StringUtils.isEmpty(team)) {
			throw new OrganizationException("对应的组织不存在");
		}
		// 当前登录人所在组织关联负责人通用角色
		Role role = orgAndProjectService.getManagerPublicRole(ProjectManagerKeyEnum._1.getKey());
		Map<String,Object> map = new HashMap<>();
		map.put("teamId", id); // 组织id 
		map.put("roleId", role.getRoleId()); // 组织负责人角色id
		map.put("roleStatus", role.getIsActive()); // 通用角色状态
		map.put("category", ProjectManagerKeyEnum._1.getKey()); // category
		// 获取详情
		TeamVo teamVo = teamMapper.queryOrg(map);
		return teamVo;
	}

	/**
	 * 获取组织列表 
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public PageInfo<OrganizationVo> list(TeamListDto teamListDto) {
		Team parentOrg = teamMapper.findOrgById(teamListDto.getParentId());
		if (StringUtils.isEmpty(parentOrg)) {
			throw new OrganizationException("请求参数有误");
		}
		// 当前登录人所在组织关联负责人通用角色
		Role managerRole = orgAndProjectService.getManagerPublicRole(ProjectManagerKeyEnum._1.getKey());
		PageHelper.startPage(teamListDto.getPage(), teamListDto.getPageSize());
		List<OrganizationVo> orgList = new ArrayList<>();
		Map<String, Object> map = new HashMap<>();
		map.put("roleId", managerRole.getRoleId()); // 角色负责人
		map.put("category", ProjectManagerKeyEnum._1.getKey()); // 1: 负责人  2：项目经理
		map.put("roleStatus", managerRole.getIsActive()); // 通用角色状态
		if (teamListDto.getContainChild()) {
			// 当前组织的所有下级列表
			String subLikeCode = orgAndProjectService.getSubLikeCode(parentOrg.getCode());
			map.put("subLikeCode", subLikeCode); 
			map.put("excludeCode", parentOrg.getCode());
			orgList = teamMapper.findOrgListByCodeLike(map);
		} else {
			map.put("parentId", teamListDto.getParentId());
			// 下一级列表
			orgList = teamMapper.findFirstSubOrgListByParentId(map);
		}
		PageInfo<OrganizationVo> pageInfo = new PageInfo(orgList);
		return pageInfo;
	}

	/**
	 * 获取组织架构树
	 * 当前登录人组织及其以下组织
	 */
	@Override
	public List<Param> tree() {
		// 获取当前登录人信息
		LoginDataVo currentUser = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		List<Param> orgTree = teamMapper.tree(currentUser.getCurrentTeam().getTeamId());
		return orgTree;
	}

	/**
	 * 获得组织项目架构图
	 */
	@Override
	public SysResult orgAndProjectTree() {
		List<OrgAndProjectTreeParam> orgAndProjectTree = teamMapper.orgAndProjectTree();
		return SysResult.ok(orgAndProjectTree);
	}
	
	/**
	 * 获得登录人所在组织下的组织/项目架构图
	 */
	@Override
	public List<OrgAndProjectTreeParam> findAllSubOrgAndProjectByOrgId() {
		// 获取当前登录人信息
		LoginDataVo currentUser = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		int orgId = currentUser.getCurrentTeam().getTeamId();
		Team org = teamMapper.findOrgById(orgId);
		if (StringUtils.isEmpty(org)) {
			return new ArrayList<>();
		}
		return teamMapper.findAllSubOrgAndProjectByOrgId(orgId);
	}
	
	///////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////// 私有方法
	///////////////////////////////////////////////////////////////////////////////////////////////////
	/**
	 * 添加组织时，校验基本信息是否合法
	 * @params parentOrg 上级组织
	 * @params organizationVo 新建组织入参
	 * @throws OrganizationException 
	 */
	private void checkAddOrg(Team parentOrg, OrganizationVo organizationVo) {
		// 当前登录人所属组织是否有编辑权限（例如：登录人为三级组织不能编辑平级和上级组织）
		int authStatus = orgAndProjectService.orgRelationship(parentOrg.getTeamId());
		if (!(-1==authStatus)) {
			throw new OrganizationException("当前登录人没有对该组织的创建权限");
		}
		if (!StringUtils.isEmpty(parentOrg)) {
			// 逻辑状态 1正常，2禁用，3 删除，目前没有删除操作先保留判断。
			if (parentOrg.getIsActive()==3) {
				throw new OrganizationException("上级组织已被删除");
			}
//			if (parentOrg.getIsActive()==2) {
//				throw new OrganizationException("禁用的组织不能新建下级组织");
//			}
			// 上级组织层级
			int parentLevel = orgAndProjectService.getOrgLevel(parentOrg.getCode());
			// 检查层次结构只能有5级（上级组织层级<=4即可）
			if (parentLevel>=5) {
				throw new OrganizationException("组织层级不能超过5级");
			}
		} else {
			throw new OrganizationException("上级组织不存在");
		}
		// 检查组织名称是否唯一(只约束同级)
		OrganizationVo equalsOrg = teamMapper.findFirstSubOrgByName(organizationVo);
		if (!StringUtils.isEmpty(equalsOrg)) {
			throw new OrganizationException("该组织已存在，请勿重复提交");
		}
	}
	
	/**
	 * 保存组织基本信息
	 * @param organizationVo 创建组织前端传递参数
	 * @param parentOrg 父级组织信息
	 * @param courrentUser 当前登录人相关信息
	 * @throws OrganizationException
	 */
	private void save(OrganizationVo organizationVo, Team parentOrg, LoginDataVo courrentUser) {
		int size = 0;
		Map<String,Object> map = new HashMap<>();
		map.put("parentId", organizationVo.getParentId());
		map.put("type", TeamTypeEnum._1.getKey());
		// 查询当前下级(所有状态： 启用、禁用、删除) 
		List<Team> firstSubOrgList = teamMapper.selectFirstAllStatusSubOrgOrProList(map);
		if (!firstSubOrgList.isEmpty()) {
			size = firstSubOrgList.size();
		}
		if (size>=999) {
			throw new OrganizationException("无法添加该组织，该层级组织数量已达上线");
		}
		// 设置创建组织的人
		organizationVo.setCreateBy(courrentUser.getUser().getUserId());
		// 设置组织/项目所属一级组织ID
		organizationVo.setFirstOrg(courrentUser.getUser().getFirstOrg()+"");
		// 下级组织状态(启用、禁用)和上级保持一致（组织已被禁用依旧可以创建组织和项目（状态为禁用））
		organizationVo.setStatus(parentOrg.getIsActive()+"");
		// 设置code
		organizationVo.setCode(orgAndProjectService.getNextCode(parentOrg.getCode(), size));
		// 保存组织基本信息
		int orgNum = teamMapper.addOrgBase(organizationVo);
		if (orgNum<1) {
			throw new OrganizationException("保存组织基本信息失败");
		}
		if (!organizationVo.getModules().isEmpty()) {
			// 批量保存组织全选模块信息
			int orgModuleNum = teamMapper.addOrgModuleAllBase(organizationVo);
			if (orgModuleNum<1) {
				throw new OrganizationException("保存组织模块关联关系失败");
			}
		}
		if (!organizationVo.getHalfmodules().isEmpty()) {
			// 批量保存组织半选模块信息
			int orgModuleNum = teamMapper.addOrgModuleHalfBase(organizationVo);
			if (orgModuleNum<1) {
				throw new OrganizationException("保存组织模块关联关系失败");
			}
		}
		if (!StringUtils.isEmpty(organizationVo.getManager())) {
			// 查询相关联的负责人角色
			Role role = orgAndProjectService.getManagerPublicRole(ProjectManagerKeyEnum._1.getKey());
			// 保存负责人
			UserTeam bean = new UserTeam();
			bean.setUserId(Integer.parseInt(organizationVo.getManager()));
			bean.setRoleId(role.getRoleId()); // 角色id
			bean.setTeamId(organizationVo.getId()); // 组织id
			bean.setCategory(ProjectManagerKeyEnum._1.getKey()); // 标识组织/项目模块获得负责人，项目经理角色：1:负责人 2:项目经理  null：其他
			bean.setIsActive(role.getIsActive()); // 逻辑状态 1正常，2禁用，3 删除
			bean.setCreateTime(new Date()); // 创建时间
			userTeamMapper.insert(bean);
		}
	}
	
	/**
	 * 编辑组织校验信息
	 * @param organizationVo 前端传递参数
	 * @param team 前端传递参数
	 * @throws OrganizationException
	 */
	private void checkEditOrg(OrganizationVo organizationVo, Team team) {
		int authStatus = orgAndProjectService.orgRelationship(organizationVo.getId());
		if (!(-1==authStatus)) {
			throw new OrganizationException("当前登录人没有对该组织的编辑权限");
		}
		// 检查组织名称是否唯一
		OrganizationVo org = teamMapper.findFirstSubOrgByName(organizationVo);
		if (!StringUtils.isEmpty(org)) {
			throw new OrganizationException("该组织已存在，请勿重复提交");
		}
		
		if (StringUtils.isEmpty(team)) {
			throw new OrganizationException("参数异常，指定组织不存在");
		}
		if (delete==team.getIsActive()) {
			throw new OrganizationException("指定组织已被删除，现无法更新");
		}
		// 编辑一级组织时不校验
		if (!StringUtils.isEmpty(team.getParentTeamId())) {
			if (team.getParentTeamId()!=organizationVo.getParentId()) {
				// 后期有允许修改上级组织的需求，可以逻辑删除旧组织，复制到新组织下
				throw new OrganizationException("不允许修改上级组织");
			}
		}
	}
	
	/**
	 * 更新组织信息
	 * @param organizationVo 编辑组织入参
	 * @param team 编辑组织的基本信息
	 * @throws OrganizationException
	 */
	private void update(OrganizationVo organizationVo, Team team) throws OrganizationException {
		// 当前登录人信息
		LoginDataVo courrentUser = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		// 设置组织/项目所属一级组织ID
		organizationVo.setFirstOrg(courrentUser.getUser().getFirstOrg()+"");
		// 更新人
		organizationVo.setCreateBy(courrentUser.getUser().getUserId());
		// 更新组织基本信息
		int num = teamMapper.updateOrgBase(organizationVo);
		if (num<1) {
			throw new OrganizationException("保存组织信息失败");
		}
		// 批量更新组织模块信息
		// 对比需要删除和新增的模块
		Set<String> removeModuleSet = new HashSet<>();
		Set<String> addAllModuleSet = new HashSet<>();
		Set<String> addHalfModuleSet = new HashSet<>();
		{
			Map<String,Object> paramsMap = new HashMap<>();
			paramsMap.put("orgId", organizationVo.getId());
			paramsMap.put("status", team.getIsActive()+"");
			// 是否全选: 1: 全选  2：半选
			paramsMap.put("isHalf", ModuleStatusEnum._1.getKey());
			List<TeamModule> teamAllModuleList = teamModuleMapper.findAllModuleByOrgId(paramsMap);
			
			// 全选模块比较
			Map<String, Set<String>> allMap = compareList(teamAllModuleList, organizationVo.getModules());
			System.out.println(allMap);
			removeModuleSet.addAll(allMap.get("removeModuleSet"));
			addAllModuleSet.addAll(allMap.get("addModuleSet"));
			
			// 是否全选: 1: 全选  2：半选
			paramsMap.put("isHalf", ModuleStatusEnum._2.getKey());
			List<TeamModule> teaHalfmModuleList = teamModuleMapper.findAllModuleByOrgId(paramsMap);
			// 半选模块比较
			Map<String, Set<String>> halfMap = compareList(teaHalfmModuleList, organizationVo.getHalfmodules());
			removeModuleSet.addAll(halfMap.get("removeModuleSet"));
			addHalfModuleSet.addAll(halfMap.get("addModuleSet"));
		}
		if (!removeModuleSet.isEmpty()) {
			int count = teamModuleMapper.deleteModuleByOrgIdAndModuleId(organizationVo.getId(), removeModuleSet);
			if (count<1) {
				throw new OrganizationException("删除组织和可用模块关联信息失败");
			}
			// 移除所有下级组织对应的可用模块
			String subLikeCode = orgAndProjectService.getSubLikeCode(team.getCode());
			Map<String, Object> subOrgParams = new HashMap<>();
			subOrgParams.put("parentCode", team.getCode());
			subOrgParams.put("subLikeCode", subLikeCode);
			subOrgParams.put("removeModuleSet", removeModuleSet);
			teamModuleMapper.removeSubOrgModuleLikeCodeAndSet(subOrgParams);
		}
		// 和更新前的状态保持一致
		organizationVo.setStatus(team.getIsActive()+"");
		if (!addAllModuleSet.isEmpty()) {
			int count = teamModuleMapper.addAllModuleByOrgIdAndModuleId(organizationVo, addAllModuleSet);
			if (count<1) {
				throw new OrganizationException("组织可用模块信息保存失败");
			}
		}
		if (!addHalfModuleSet.isEmpty()) {
			int count = teamModuleMapper.addHalfModuleByOrgIdAndModuleId(organizationVo, addHalfModuleSet);
			if (count<1) {
				throw new OrganizationException("组织可用模块信息保存失败");
			}
		}
	}
	
	/**
	 * 比较两个集合
	 * @param oldTeamModuleList 数据库保存的team_module
	 * @param newModuleList 编辑之后的team_module
	 */
	private Map<String, Set<String>> compareList(List<TeamModule> oldTeamModuleList, List<String> newModuleList) {
		Map<String, Set<String>> resultMap = new HashMap<>();
		Set<String> removeModuleSet = new HashSet<>();
		oldTeamModuleList.forEach(module->{
			removeModuleSet.add(module.getModuleId()+"");
		});
		
		Set<String> copySaveModuleSet = new HashSet<>(removeModuleSet);
		Set<String> addModuleSet = new HashSet<>(newModuleList);
		
		// 需要删除的集合
		removeModuleSet.removeAll(addModuleSet);
		// 需要增加的集合
		addModuleSet.removeAll(copySaveModuleSet);
		resultMap.put("removeModuleSet", removeModuleSet);
		resultMap.put("addModuleSet", addModuleSet);
		return resultMap;
	}
	
}
